<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<HTML>
  <HEAD>
    <META name="generator" content=
    "HTML Tidy for Java (vers. 2009-12-01), see jtidy.sourceforge.net">
    <META http-equiv="Content-Type" content="text/html; charset=windows-1252">

    <TITLE>Regular Expressions</TITLE>
    <LINK rel="stylesheet" type="text/css" href="help/shared/DefaultStyle.css">
    <META name="generator" content="Microsoft FrontPage 4.0">
  </HEAD>

  <BODY>
    <H1><A name="Memory_Regular_Expressions"></A>Regular Expressions</H1>

    <P>Many searches and filters in Ghidra can use regular expressions..
    Ghidra uses Java's built-in regular expressions grammar, so the syntax is exactly the
    same as a regular expression for any standard Java application.

    <BLOCKQUOTE>  
    <H3>Examples</H3>

    <BLOCKQUOTE>
      <TABLE border="1" width="80%">
        <TBODY>
          <TR>
            <TD>
              <P><B>cafebabe</B></P>
            </TD>

            <TD>
              <P>Searches for the string "cafebabe"</P>
            </TD>
          </TR>

          <TR>
            <TD>
              <P><B>\x30\x31</B></P>
            </TD>

            <TD>
              <P>Searches for the byte 0x30 followed by the byte 0x31</P>
            </TD>
          </TR>

          <TR>
            <TD>
              <P><B>abc\n[^a]abc</B></P>
            </TD>

            <TD>
              <P>Searches for "abc" followed by LF, followed by any character other than a,
              followed by "abc"</P>
            </TD>
          </TR>

          <TR>
            <TD>
              <P><B>[a-z]{1,5}.</B></P>
            </TD>

            <TD>
              <P>Searches for any letter in the range a-z occurring 1-5 times followed by any
              character</P>
            </TD>
          </TR>

          <TR>
            <TD>
              <P><B>\x50.{0,10}\x55</B></P>
            </TD>

            <TD>
              <P>Searches for 0x50 followed by 0-10 occurrences of any character, followed by
              0x55</P>
            </TD>
          </TR>
          
          <TR>
            <TD width="220">
              <P><B>(..[\x50-\x5f]\x00)\1{15}</B></P>
            </TD>

            <TD>
              <P>Matches 16 runs of an address, in a row, with the value <tt>0x005????</tt>, 
              where ?? can be any byte value; for example, 0x00512345</P>
            </TD>
          </TR>
          
        </TBODY>
      </TABLE>
    </BLOCKQUOTE>

    <H3><A name="Regex_Syntax"/>Regular Expression Syntax</H3>

    <BLOCKQUOTE>
      <P>The following is the full syntax for Java's regular expression grammar from Oracle's
      Pattern class javadoc (https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)</P>

      <BR>
      <TABLE border="0" cellpadding="1" cellspacing="0" summary=
      "Regular expression constructs, and what they match">
        <TBODY>
          <TR align="left">
            <TH bgcolor="#CCCCFF" align="left" id="construct">Construct</TH>

            <TH bgcolor="#CCCCFF" align="left" id="matches">Matches</TH>
          </TR>

          <TR>
            <TD>&nbsp;</TD>
            <TD>&nbsp;</TD>
          </TR>

          <TR align="left">
            <TD align="left"><B>Characters</B></TD>

            <TD/>
          </TR>

          <TR>
            <TD valign="top" headers="construct characters"><I>x</I></TD>

            <TD headers="matches">The character <I>x</I></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct characters"><TT>\\</TT></TD>

            <TD headers="matches">The backslash character</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct characters"><TT>\0</TT><I>n</I></TD>

            <TD headers="matches">The character with octal value <TT>0</TT><I>n</I>
            (0&nbsp;<TT>&lt;=</TT>&nbsp;<I>n</I>&nbsp;<TT>&lt;=</TT>&nbsp;7)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct characters"><TT>\0</TT><I>nn</I></TD>

            <TD headers="matches">The character with octal value <TT>0</TT><I>nn</I>
            (0&nbsp;<TT>&lt;=</TT>&nbsp;<I>n</I>&nbsp;<TT>&lt;=</TT>&nbsp;7)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct characters"><TT>\0</TT><I>mnn</I></TD>

            <TD headers="matches">The character with octal value <TT>0</TT><I>mnn</I>
            (0&nbsp;<TT>&lt;=</TT>&nbsp;<I>m</I>&nbsp;<TT>&lt;=</TT>&nbsp;3,
            0&nbsp;<TT>&lt;=</TT>&nbsp;<I>n</I>&nbsp;<TT>&lt;=</TT>&nbsp;7)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct characters"><TT>\x</TT><I>hh</I></TD>

            <TD headers="matches">The character with
            hexadecimal&nbsp;value&nbsp;<TT>0x</TT><I>hh</I></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct characters"><TT>\u</TT><I>hhhh</I></TD>

            <TD headers="matches">The character with
            hexadecimal&nbsp;value&nbsp;<TT>0x</TT><I>hhhh</I></TD>
          </TR>

          <TR>
            <TD valign="top" headers="matches"><TT>\t</TT></TD>

            <TD headers="matches">The tab character (<TT>'\u0009'</TT>)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct characters"><TT>\n</TT></TD>

            <TD headers="matches">The newline (line feed) character (<TT>'\u000A'</TT>)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct characters"><TT>\r</TT></TD>

            <TD headers="matches">The carriage-return character (<TT>'\u000D'</TT>)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct characters"><TT>\f</TT></TD>

            <TD headers="matches">The form-feed character (<TT>'\u000C'</TT>)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct characters"><TT>\a</TT></TD>

            <TD headers="matches">The alert (bell) character (<TT>'\u0007'</TT>)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct characters"><TT>\e</TT></TD>

            <TD headers="matches">The escape character (<TT>'\u001B'</TT>)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct characters"><TT>\c</TT><I>x</I></TD>

            <TD headers="matches">The control character corresponding to <I>x</I></TD>
          </TR>



          <TR>
            <TD>&nbsp;</TD>
            <TD>&nbsp;</TD>
          </TR>

          <TR align="left">
            <TD align="left"><B>Character classes</B></TD>

            <TD/>
          </TR>

          <TR>
            <TD valign="top" headers="construct classes"><TT>[abc]</TT></TD>

            <TD headers="matches"><TT>a</TT>, <TT>b</TT>, or <TT>c</TT> (simple class)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct classes"><TT>[^abc]</TT></TD>

            <TD headers="matches">Any character except <TT>a</TT>, <TT>b</TT>, or <TT>c</TT>
            (negation)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct classes"><TT>[a-zA-Z]</TT></TD>

            <TD headers="matches"><TT>a</TT> through <TT>z</TT> or <TT>A</TT> through <TT>Z</TT>,
            inclusive (range)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct classes"><TT>[a-d[m-p]]</TT></TD>

            <TD headers="matches"><TT>a</TT> through <TT>d</TT>, or <TT>m</TT> through <TT>p</TT>:
            <TT>[a-dm-p]</TT> (union)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct classes"><TT>[a-z&amp;&amp;[def]]</TT></TD>

            <TD headers="matches"><TT>d</TT>, <TT>e</TT>, or <TT>f</TT> (intersection)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct classes"><TT>[a-z&amp;&amp;[^bc]]</TT></TD>

            <TD headers="matches"><TT>a</TT> through <TT>z</TT>, except for <TT>b</TT> and
            <TT>c</TT>: <TT>[ad-z]</TT> (subtraction)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct classes"><TT>[a-z&amp;&amp;[^m-p]]</TT></TD>

            <TD headers="matches"><TT>a</TT> through <TT>z</TT>, and not <TT>m</TT> through
            <TT>p</TT>: <TT>[a-lq-z]</TT> (subtraction)</TD>
          </TR>

          <TR>
            <TD>&nbsp;</TD>
            <TD>&nbsp;</TD>
          </TR>

          <TR align="left">
            <TD><B>Predefined character classes</B></TD>

            <TD/>
          </TR>

          <TR>
            <TD valign="top" headers="construct predef" align="left"><TT>.</TT></TD>

            <TD headers="matches">Any character (may or may not match line terminators)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct predef"><TT>\d</TT></TD>

            <TD headers="matches">A digit: <TT>[0-9]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct predef"><TT>\D</TT></TD>

            <TD headers="matches">A non-digit: <TT>[^0-9]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct predef"><TT>\s</TT></TD>

            <TD headers="matches">A whitespace character: <TT>[ \t\n\x0B\f\r]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct predef"><TT>\S</TT></TD>

            <TD headers="matches">A non-whitespace character: <TT>[^\s]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct predef"><TT>\w</TT></TD>

            <TD headers="matches">A word character: <TT>[a-zA-Z_0-9]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct predef"><TT>\W</TT></TD>

            <TD headers="matches">A non-word character: <TT>[^\w]</TT></TD>
          </TR>

          <TR>
            <TD>&nbsp;</TD>
            <TD>&nbsp;</TD>
          </TR>

          <TR>
            <TD align="left" colspan="2">
              <B>POSIX character classes&nbsp;(US-ASCII only)</B>
            </TD>

          </TR>

          <TR>
            <TD valign="top" headers="construct posix"><TT>\p{Lower}</TT></TD>

            <TD headers="matches">A lower-case alphabetic character: <TT>[a-z]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct posix"><TT>\p{Upper}</TT></TD>

            <TD headers="matches">An upper-case alphabetic character:<TT>[A-Z]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct posix"><TT>\p{ASCII}</TT></TD>

            <TD headers="matches">All ASCII:<TT>[\x00-\x7F]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct posix"><TT>\p{Alpha}</TT></TD>

            <TD headers="matches">An alphabetic character:<TT>[\p{Lower}\p{Upper}]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct posix"><TT>\p{Digit}</TT></TD>

            <TD headers="matches">A decimal digit: <TT>[0-9]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct posix"><TT>\p{Alnum}</TT></TD>

            <TD headers="matches">An alphanumeric character:<TT>[\p{Alpha}\p{Digit}]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct posix"><TT>\p{Punct}</TT></TD>

            <TD headers="matches">Punctuation: One of
            <TT>!"#$%&amp;'()*+,-./:;&lt;=&gt;?@[\]^_`{|}~</TT></TD>
          </TR><!-- <tt>[\!"#\$%&'\(\)\*\+,\-\./:;\<=\>\?@\[\\\]\^_`\{\|\}~]</tt>
                    <tt>[\X21-\X2F\X31-\X40\X5B-\X60\X7B-\X7E]</tt> -->

          <TR>
            <TD valign="top" headers="construct posix"><TT>\p{Graph}</TT></TD>

            <TD headers="matches">A visible character: <TT>[\p{Alnum}\p{Punct}]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct posix"><TT>\p{Print}</TT></TD>

            <TD headers="matches">A printable character: <TT>[\p{Graph}]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct posix"><TT>\p{Blank}</TT></TD>

            <TD headers="matches">A space or a tab: <TT>[ \t]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct posix"><TT>\p{Cntrl}</TT></TD>

            <TD headers="matches">A control character: <TT>[\x00-\x1F\x7F]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct posix"><TT>\p{XDigit}</TT></TD>

            <TD headers="matches">A hexadecimal digit: <TT>[0-9a-fA-F]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct posix"><TT>\p{Space}</TT></TD>

            <TD headers="matches">A whitespace character: <TT>[ \t\n\x0B\f\r]</TT></TD>
          </TR>

          <TR>
            <TD>&nbsp;</TD>
            <TD>&nbsp;</TD>
          </TR>

          <TR align="left">
          	<TD align="left" colspan="2">
              	<B> Classes for Unicode blocks&nbsp;and categories</B>
            </TD>

            <TD/>
          </TR>

          <TR>
            <TD valign="top" headers="construct unicode"><TT>\p{InGreek}</TT></TD>

            <TD headers="matches">A character in the Greek&nbsp;block (simple block)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct unicode"><TT>\p{Lu}</TT></TD>

            <TD headers="matches">An uppercase letter (simple category)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct unicode"><TT>\p{Sc}</TT></TD>

            <TD headers="matches">A currency symbol</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct unicode"><TT>\P{InGreek}</TT></TD>

            <TD headers="matches">Any character except one in the Greek block (negation)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct unicode">
            <TT>[\p{L}&amp;&amp;[^\p{Lu}]]&nbsp;</TT></TD>

            <TD headers="matches">Any letter except an uppercase letter (subtraction)</TD>
          </TR>

          <TR>
            <TD>&nbsp;</TD>
            <TD>&nbsp;</TD>
          </TR>

          <TR align="left">
          	<TD align="left"><B>Boundary matchers</B></TD>

            <TD/>
          </TR>

          <TR>
            <TD valign="top" headers="construct bounds"><TT>^</TT></TD>

            <TD headers="matches">The beginning of a line</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct bounds"><TT>$</TT></TD>

            <TD headers="matches">The end of a line</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct bounds"><TT>\b</TT></TD>

            <TD headers="matches">A word boundary</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct bounds"><TT>\B</TT></TD>

            <TD headers="matches">A non-word boundary</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct bounds"><TT>\A</TT></TD>

            <TD headers="matches">The beginning of the input</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct bounds"><TT>\G</TT></TD>

            <TD headers="matches">The end of the previous match</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct bounds"><TT>\Z</TT></TD>

            <TD headers="matches">The end of the input but for the final terminator,
            if&nbsp;any</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct bounds"><TT>\z</TT></TD>

            <TD headers="matches">The end of the input</TD>
          </TR>

          <TR>
            <TD>&nbsp;</TD>
            <TD>&nbsp;</TD>
          </TR>

          <TR align="left">
			<TD align="left"><B>Greedy quantifiers</B></TD>

            <TD/>
          </TR>

          <TR>
            <TD valign="top" headers="construct greedy"><I>X</I><TT>?</TT></TD>

            <TD headers="matches"><I>X</I>, once or not at all</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct greedy"><I>X</I><TT>*</TT></TD>

            <TD headers="matches"><I>X</I>, zero or more times</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct greedy"><I>X</I><TT>+</TT></TD>

            <TD headers="matches"><I>X</I>, one or more times</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct greedy"><I>X</I><TT>{</TT><I>n</I><TT>}</TT></TD>

            <TD headers="matches"><I>X</I>, exactly <I>n</I> times</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct greedy"><I>X</I><TT>{</TT><I>n</I><TT>,}</TT></TD>

            <TD headers="matches"><I>X</I>, at least <I>n</I> times</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct greedy">
            <I>X</I><TT>{</TT><I>n</I><TT>,</TT><I>m</I><TT>}</TT></TD>

            <TD headers="matches"><I>X</I>, at least <I>n</I> but not more than <I>m</I> times</TD>
          </TR>

          <TR>
            <TD>&nbsp;</TD>
            <TD>&nbsp;</TD>
          </TR>

          <TR align="left">
            <TD align="left"><B>Reluctant quantifiers</B></TD>
  
            <TD/>
          </TR>

          <TR>
            <TD valign="top" headers="construct reluc"><I>X</I><TT>??</TT></TD>

            <TD headers="matches"><I>X</I>, once or not at all</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct reluc"><I>X</I><TT>*?</TT></TD>

            <TD headers="matches"><I>X</I>, zero or more times</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct reluc"><I>X</I><TT>+?</TT></TD>

            <TD headers="matches"><I>X</I>, one or more times</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct reluc"><I>X</I><TT>{</TT><I>n</I><TT>}?</TT></TD>

            <TD headers="matches"><I>X</I>, exactly <I>n</I> times</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct reluc"><I>X</I><TT>{</TT><I>n</I><TT>,}?</TT></TD>

            <TD headers="matches"><I>X</I>, at least <I>n</I> times</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct reluc">
            <I>X</I><TT>{</TT><I>n</I><TT>,</TT><I>m</I><TT>}?</TT></TD>

            <TD headers="matches"><I>X</I>, at least <I>n</I> but not more than <I>m</I> times</TD>
          </TR>

          <TR>
            <TD>&nbsp;</TD>
            <TD>&nbsp;</TD>
          </TR>

          <TR align="left">
          <TD align="left"><B>Possessive quantifiers</B></TD>

            <TD/>
          </TR>

          <TR>
            <TD valign="top" headers="construct poss"><I>X</I><TT>?+</TT></TD>

            <TD headers="matches"><I>X</I>, once or not at all</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct poss"><I>X</I><TT>*+</TT></TD>

            <TD headers="matches"><I>X</I>, zero or more times</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct poss"><I>X</I><TT>++</TT></TD>

            <TD headers="matches"><I>X</I>, one or more times</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct poss"><I>X</I><TT>{</TT><I>n</I><TT>}+</TT></TD>

            <TD headers="matches"><I>X</I>, exactly <I>n</I> times</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct poss"><I>X</I><TT>{</TT><I>n</I><TT>,}+</TT></TD>

            <TD headers="matches"><I>X</I>, at least <I>n</I> times</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct poss">
            <I>X</I><TT>{</TT><I>n</I><TT>,</TT><I>m</I><TT>}+</TT></TD>

            <TD headers="matches"><I>X</I>, at least <I>n</I> but not more than <I>m</I> times</TD>
          </TR>

          <TR>
            <TD>&nbsp;</TD>
            <TD>&nbsp;</TD>
          </TR>

          <TR align="left">
          <TD align="left"><B>Logical operators</B></TD>
          
            <TD/>
          </TR>

          <TR>
            <TD valign="top" headers="construct logical"><I>XY</I></TD>

            <TD headers="matches"><I>X</I> followed by <I>Y</I></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct logical"><I>X</I><TT>|</TT><I>Y</I></TD>

            <TD headers="matches">Either <I>X</I> or <I>Y</I></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct logical"><TT>(</TT><I>X</I><TT>)</TT></TD>

            <TD headers="matches">X, as a capturing group</TD>
          </TR>

          <TR>
            <TD>&nbsp;</TD>
            <TD>&nbsp;</TD>
          </TR>

          <TR align="left">
          	<TD align="left"><B>Back references</B></TD>

            <TD/>
          </TR>

          <TR>
            <TD valign="bottom" headers="construct backref"><TT>\</TT><I>n</I></TD>

            <TD valign="bottom" headers="matches">Whatever the <I>n</I><SUP>th</SUP> capturing
            group matched</TD>
          </TR>

          <TR>
            <TD>&nbsp;</TD>
            <TD>&nbsp;</TD>
          </TR>

          <TR align="left">
          	<TD align="left"><B>Quotation</B></TD>

            <TD/>
          </TR>

          <TR>
            <TD valign="top" headers="construct quot"><TT>\</TT></TD>

            <TD headers="matches">Nothing, but quotes the following character</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct quot"><TT>\Q</TT></TD>

            <TD headers="matches">Nothing, but quotes all characters until <TT>\E</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct quot"><TT>\E</TT></TD>

            <TD headers="matches">Nothing, but ends quoting started by <TT>\Q</TT></TD>
          </TR><!-- Metachars: !$()*+.<>?[\]^{|} -->

          <TR>
            <TD>&nbsp;</TD>
            <TD>&nbsp;</TD>
          </TR>

          <TR align="left">
          	<TD align="left" colspan="2"><B>Special constructs&nbsp; (non-capturing)</B></TD>

            </TH>  

            <TD/>
          </TR>

          <TR>
            <TD valign="top" headers="construct special"><TT>(?:</TT><I>X</I><TT>)</TT></TD>

            <TD headers="matches"><I>X</I>, as a non-capturing group</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct special"><TT>(?idmsux-idmsux)&nbsp;</TT></TD>

            <TD headers="matches">Nothing, but turns match flags on - off</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct special">
            <TT>(?idmsux-idmsux:</TT><I>X</I><TT>)</TT>&nbsp;&nbsp;</TD>

            <TD headers="matches"><I>X</I>, as a non-capturing group with the given flags on -
            off</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct special"><TT>(?=</TT><I>X</I><TT>)</TT></TD>

            <TD headers="matches"><I>X</I>, via zero-width positive lookahead</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct special"><TT>(?!</TT><I>X</I><TT>)</TT></TD>

            <TD headers="matches"><I>X</I>, via zero-width negative lookahead</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct special"><TT>(?&lt;=</TT><I>X</I><TT>)</TT></TD>

            <TD headers="matches"><I>X</I>, via zero-width positive lookbehind</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct special"><TT>(?&lt;!</TT><I>X</I><TT>)</TT></TD>

            <TD headers="matches"><I>X</I>, via zero-width negative lookbehind</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct special"><TT>(?&gt;</TT><I>X</I><TT>)</TT></TD>

            <TD headers="matches"><I>X</I>, as an independent, non-capturing group</TD>
          </TR>
        </TBODY>
      </TABLE>
    </BLOCKQUOTE>

    <BR>
	<BR>
	<BR>
  </BODY>
</HTML>
